import { AIConfig, ConversationContext, EntityPersona } from './types';
import { getEntityPersona } from './EntityPersonas';
import { configManager } from './ConfigManager';
import { mockAIService } from './MockAIService';
import { configUI } from './ConfigUI';
import { proxyService } from './ProxyService';

// AI服务接口
export interface IAIService {
  configure(config: AIConfig): void;
  generateResponse(
    message: string, 
    context: ConversationContext,
    persona: EntityPersona
  ): Promise<string>;
  isConfigured(): boolean;
  handleError(error: Error): string;
}

// 千问-max API服务实现
export class QwenAIService implements IAIService {
  private config: AIConfig | null = null;
  private isReady = false;
  private useMockService = false;
  private corsErrorDetected = false;

  constructor() {
    this.loadConfiguration();
  }

  // 配置AI服务
  configure(config: AIConfig): void {
    this.config = config;
    this.isReady = this.validateConfig(config);
  }

  // 从配置管理器加载配置
  private loadConfiguration(): void {
    try {
      const config = configManager.getAIConfig();
      if (config) {
        this.configure(config);
      }
    } catch (error) {
      console.warn('Failed to load AI configuration:', error);
    }
  }

  // 重新加载配置
  reloadConfiguration(): void {
    configManager.reloadConfig();
    this.loadConfiguration();
  }

  // 验证配置
  private validateConfig(config: AIConfig): boolean {
    return !!(
      config.apiUrl && 
      config.apiKey && 
      config.model &&
      config.maxTokens > 0 &&
      config.temperature >= 0 &&
      config.temperature <= 2 &&
      config.timeout > 0
    );
  }

  // 检查是否已配置
  isConfigured(): boolean {
    return this.isReady && this.config !== null;
  }

  // 生成AI回复
  async generateResponse(
    message: string, 
    context: ConversationContext,
    persona: EntityPersona
  ): Promise<string> {
    // 检查是否应该使用模拟服务
    const shouldUseMock = this.useMockService || this.corsErrorDetected || configUI.isUsingMockService();
    
    if (shouldUseMock) {
      console.log('使用模拟AI服务生成回复');
      mockAIService.configure(this.config || this.getDefaultConfig());
      return await mockAIService.generateResponse(message, context, persona);
    }

    if (!this.isConfigured() || !this.config) {
      throw new Error('AI服务未正确配置');
    }

    try {
      const prompt = this.buildPrompt(message, context, persona);
      const response = await this.callAPI(prompt);
      return this.extractResponse(response);
    } catch (error) {
      console.error('AI服务调用失败:', error);
      
      // 检测CORS错误
      if (this.isCorsError(error)) {
        console.warn('检测到CORS错误，切换到模拟AI服务');
        this.corsErrorDetected = true;
        mockAIService.configure(this.config);
        return await mockAIService.generateResponse(message, context, persona);
      }
      
      throw error;
    }
  }

  // 构建提示词
  private buildPrompt(
    message: string, 
    context: ConversationContext, 
    persona: EntityPersona
  ): string {
    const systemPrompt = this.buildSystemPrompt(persona, context);
    const conversationHistory = this.buildConversationHistory(context);
    
    return `${systemPrompt}

${conversationHistory}

玩家: ${message}
${persona.name}:`;
  }

  // 构建系统提示词
  private buildSystemPrompt(persona: EntityPersona, context: ConversationContext): string {
    return `你是《我的世界》游戏中的一只${persona.name}。请严格按照以下设定进行角色扮演：

角色设定：
- 名称：${persona.name}
- 个性：${persona.personality}
- 背景：${persona.background}
- 说话风格：${persona.speechStyle}
- 兴趣爱好：${persona.interests.join('、')}

游戏环境：
- 时间：${context.gameContext.timeOfDay}
- 天气：${context.gameContext.weather}
- 玩家位置：(${context.gameContext.playerPosition.x}, ${context.gameContext.playerPosition.y}, ${context.gameContext.playerPosition.z})

对话规则：
1. 严格保持角色设定，不要脱离角色
2. 回复要简短自然，符合游戏对话风格
3. 使用角色特有的语气词和表达方式
4. 可以提及游戏中的元素（方块、物品、其他生物等）
5. 保持友好互动，避免过于复杂的话题
6. 每次回复控制在1-3句话以内

请开始角色扮演：`;
  }

  // 构建对话历史
  private buildConversationHistory(context: ConversationContext): string {
    const recentHistory = context.history.slice(-10); // 只取最近10条消息
    
    return recentHistory.map(msg => {
      const speaker = msg.sender === 'player' ? '玩家' : context.entityType;
      return `${speaker}: ${msg.content}`;
    }).join('\n');
  }

  // 调用API
  private async callAPI(prompt: string): Promise<any> {
    if (!this.config) {
      throw new Error('AI配置未初始化');
    }

    const requestBody = {
      model: this.config.model,
      input: {
        messages: [
          {
            role: 'user',
            content: prompt
          }
        ]
      },
      parameters: {
        max_tokens: this.config.maxTokens,
        temperature: this.config.temperature,
        top_p: 0.8,
        repetition_penalty: 1.1
      }
    };

    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);

    try {
      // 使用改进的代理服务
      const response = await this.callAPIWithProxy(requestBody, controller.signal);
      clearTimeout(timeoutId);

      if (!response.ok) {
        const errorInfo = await this.extractErrorInfo(response);
        throw new Error(`API调用失败: ${response.status} ${response.statusText} - ${errorInfo}`);
      }

      const result = await response.json();
      console.log('✅ API调用成功，收到回复');
      return result;
    } catch (error) {
      clearTimeout(timeoutId);
      
      if ((error as Error).name === 'AbortError') {
        throw new Error('API调用超时');
      }
      
      console.error('❌ API调用错误:', error);
      throw error;
    }
  }

  // 使用代理服务调用API
  private async callAPIWithProxy(requestBody: any, signal: AbortSignal): Promise<Response> {
    if (!this.config) {
      throw new Error('AI配置未初始化');
    }

    // 检查是否使用本地代理
    const proxyStatus = proxyService.getProxyStatus();
    console.log('🔍 代理状态:', proxyStatus);

    if (proxyStatus.localProxyHealth) {
      // 使用本地代理
      console.log('🔄 使用本地代理服务器');
      return await this.callViaLocalProxy(requestBody, signal);
    } else {
      // 使用ProxyService的智能代理选择
      console.log('🔄 使用ProxyService智能代理');
      return await this.callViaProxyService(requestBody, signal);
    }
  }

  // 通过本地代理调用
  private async callViaLocalProxy(requestBody: any, signal: AbortSignal): Promise<Response> {
    return await fetch('http://localhost:3001/api/chat', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.config!.apiKey}`
      },
      body: JSON.stringify(requestBody),
      signal
    });
  }

  // 通过ProxyService调用
  private async callViaProxyService(requestBody: any, signal: AbortSignal): Promise<Response> {
    const options: RequestInit = {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.config!.apiKey}`,
        'X-DashScope-SSE': 'disable'
      },
      body: JSON.stringify(requestBody),
      signal
    };

    return await proxyService.proxyFetch(this.config!.apiUrl, options);
  }

  // 提取错误信息
  private async extractErrorInfo(response: Response): Promise<string> {
    try {
      const errorData = await response.json();
      return errorData.message || errorData.error || JSON.stringify(errorData);
    } catch {
      try {
        return await response.text();
      } catch {
        return '未知错误';
      }
    }
  }



  // 提取回复内容
  private extractResponse(apiResponse: any): string {
    try {
      if (apiResponse.output && apiResponse.output.choices && apiResponse.output.choices.length > 0) {
        const choice = apiResponse.output.choices[0];
        if (choice.message && choice.message.content) {
          return choice.message.content.trim();
        }
      }
      
      throw new Error('API响应格式不正确');
    } catch (error) {
      console.error('解析API响应失败:', error, apiResponse);
      throw new Error('解析AI回复失败');
    }
  }

  // 错误处理
  handleError(error: Error): string {
    const errorMessage = error.message.toLowerCase();
    
    if (errorMessage.includes('timeout') || errorMessage.includes('超时')) {
      return '抱歉，我现在有点累，请稍后再试...';
    }
    
    if (errorMessage.includes('rate limit') || errorMessage.includes('频率限制')) {
      return '我需要休息一下，请过一会儿再和我聊天。';
    }
    
    if (errorMessage.includes('network') || errorMessage.includes('网络')) {
      return '我好像听不清楚，网络有点问题...';
    }
    
    if (errorMessage.includes('unauthorized') || errorMessage.includes('认证')) {
      return '我现在无法正常思考，可能是配置有问题...';
    }
    
    if (errorMessage.includes('quota') || errorMessage.includes('配额')) {
      return '我今天说话太多了，需要休息一下。';
    }
    
    // 默认错误回复
    return '我现在有点困惑，请再说一遍好吗？';
  }

  // 检测是否为CORS错误
  private isCorsError(error: any): boolean {
    const errorMessage = error?.message?.toLowerCase() || '';
    
    // 明确的CORS错误标识
    const corsIndicators = [
      'cors',
      'cross-origin',
      'strict-origin-when-cross-origin',
      'access-control-allow-origin',
      'preflight'
    ];
    
    // 网络错误可能是CORS导致的
    const networkErrorIndicators = [
      'network error',
      'failed to fetch',
      'net::err_failed'
    ];
    
    // 检查明确的CORS错误
    if (corsIndicators.some(indicator => errorMessage.includes(indicator))) {
      return true;
    }
    
    // 检查可能的CORS相关网络错误（但要排除其他网络问题）
    if (networkErrorIndicators.some(indicator => errorMessage.includes(indicator))) {
      // 如果是TypeError且包含fetch，很可能是CORS问题
      if (error?.name === 'TypeError' && errorMessage.includes('fetch')) {
        return true;
      }
    }
    
    return false;
  }

  // 获取默认配置
  private getDefaultConfig(): AIConfig {
    return {
      apiUrl: 'https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation',
      apiKey: 'mock-key',
      model: 'qwen-max',
      maxTokens: 1000,
      temperature: 0.7,
      timeout: 10000
    };
  }

  // 设置使用模拟服务
  public setUseMockService(useMock: boolean): void {
    this.useMockService = useMock;
    if (useMock) {
      console.log('已切换到模拟AI服务模式');
    }
  }

  // 检查是否使用模拟服务
  public isUsingMockService(): boolean {
    return this.useMockService || this.corsErrorDetected;
  }

  // 重置CORS错误状态
  public resetCorsError(): void {
    this.corsErrorDetected = false;
  }

  // 获取配置信息（用于调试）
  getConfig(): AIConfig | null {
    return this.config ? { ...this.config, apiKey: '***' } : null;
  }
}

// 备用回复服务（当AI服务不可用时使用）
export class FallbackResponseService {
  private fallbackResponses: Record<string, string[]> = {
    cow: [
      '哞~ 我现在有点困，请稍后再聊吧。',
      '哞哞~ 草地上的风景真美呢。',
      '我正在想一些关于牛奶的事情...',
      '哞~ 你说什么？我刚才在发呆。',
      '今天的草特别香甜呢，哞~'
    ],
    pig: [
      '哼哼~ 我在想哪里有好吃的。',
      '抱歉，我刚才在打盹呢。',
      '哼~ 你说什么？我没听清楚。',
      '哼哼~ 我肚子有点饿了。',
      '你有胡萝卜吗？哼哼~'
    ],
    sheep: [
      '咩~ 我有点紧张，能再说一遍吗？',
      '咩咩~ 我刚才在想别的事情。',
      '对不起，我没听清楚，咩~',
      '咩~ 这里很安全吧？',
      '我的毛今天很蓬松呢，咩~'
    ],
    zombie: [
      '呃...我的脑子...有点混乱...',
      '啊...刚才想起了什么...但忘记了...',
      '呃呃...你说什么？',
      '我...记不清楚了...',
      '呃...夜晚...让我更清醒...'
    ],
    skeleton: [
      '我在思考更深层的问题...',
      '时间对我来说毫无意义...',
      '你的话让我想起了什么...',
      '死亡...是永恒的沉默...',
      '我见过太多生者的来来去去...'
    ]
  };

  getFallbackResponse(entityType: string): string {
    const responses = this.fallbackResponses[entityType];
    if (!responses || responses.length === 0) {
      return '...';
    }
    
    return responses[Math.floor(Math.random() * responses.length)];
  }
}

// 导出默认AI服务实例
export const aiService = new QwenAIService();
export const fallbackService = new FallbackResponseService();